// $ANTLR 3.4 C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g 2012-10-18 22:21:06

   package flexgram;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class FlexLexer extends Lexer {
    public static final int EOF=-1;
    public static final int ASTER=4;
    public static final int BLOQCL=5;
    public static final int BLOQOP=6;
    public static final int CAR=7;
    public static final int CHAR=8;
    public static final int CJTOCAR=9;
    public static final int COMA=10;
    public static final int COMMENT=11;
    public static final int CORCL=12;
    public static final int COROP=13;
    public static final int EQ=14;
    public static final int ESC_SEQ=15;
    public static final int EXPONENT=16;
    public static final int FLOAT=17;
    public static final int HEX_DIGIT=18;
    public static final int ID=19;
    public static final int IND=20;
    public static final int INT=21;
    public static final int LLAVCL=22;
    public static final int LLAVOP=23;
    public static final int NEWLINE=24;
    public static final int OCTAL_ESC=25;
    public static final int OPINC=26;
    public static final int OR=27;
    public static final int PARCL=28;
    public static final int PAROP=29;
    public static final int PLUS=30;
    public static final int RANGO=31;
    public static final int REF=32;
    public static final int SECCION=33;
    public static final int SEMI=34;
    public static final int SPACE=35;
    public static final int STR=36;
    public static final int STRING=37;
    public static final int UNICODE_ESC=38;

    // delegates
    // delegators
    public Lexer[] getDelegates() {
        return new Lexer[] {};
    }

    public FlexLexer() {} 
    public FlexLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public FlexLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);
    }
    public String getGrammarFileName() { return "C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g"; }

    // $ANTLR start "CAR"
    public final void mCAR() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:20:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | ' ' | '%' | '=' | '\\\\' ) )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            {
            if ( input.LA(1)==' '||input.LA(1)=='%'||(input.LA(1) >= '0' && input.LA(1) <= '9')||input.LA(1)=='='||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='\\'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CAR"

    // $ANTLR start "STR"
    public final void mSTR() throws RecognitionException {
        try {
            int _type = STR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:21:9: ( '\"' ( CAR )* '\"' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:21:11: '\"' ( CAR )* '\"'
            {
            match('\"'); 

            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:21:15: ( CAR )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==' '||LA1_0=='%'||(LA1_0 >= '0' && LA1_0 <= '9')||LA1_0=='='||(LA1_0 >= 'A' && LA1_0 <= 'Z')||LA1_0=='\\'||(LA1_0 >= 'a' && LA1_0 <= 'z')) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            	    {
            	    if ( input.LA(1)==' '||input.LA(1)=='%'||(input.LA(1) >= '0' && input.LA(1) <= '9')||input.LA(1)=='='||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='\\'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "STR"

    // $ANTLR start "ID"
    public final void mID() throws RecognitionException {
        try {
            int _type = ID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:23:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:23:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            {
            if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:23:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( ((LA2_0 >= '0' && LA2_0 <= '9')||(LA2_0 >= 'A' && LA2_0 <= 'Z')||LA2_0=='_'||(LA2_0 >= 'a' && LA2_0 <= 'z')) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ID"

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:26:5: ( ( '0' .. '9' )+ )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:26:7: ( '0' .. '9' )+
            {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:26:7: ( '0' .. '9' )+
            int cnt3=0;
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( ((LA3_0 >= '0' && LA3_0 <= '9')) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt3 >= 1 ) break loop3;
                        EarlyExitException eee =
                            new EarlyExitException(3, input);
                        throw eee;
                }
                cnt3++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "FLOAT"
    public final void mFLOAT() throws RecognitionException {
        try {
            int _type = FLOAT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:30:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT )
            int alt10=3;
            alt10 = dfa10.predict(input);
            switch (alt10) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:30:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )?
                    {
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:30:9: ( '0' .. '9' )+
                    int cnt4=0;
                    loop4:
                    do {
                        int alt4=2;
                        int LA4_0 = input.LA(1);

                        if ( ((LA4_0 >= '0' && LA4_0 <= '9')) ) {
                            alt4=1;
                        }


                        switch (alt4) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt4 >= 1 ) break loop4;
                                EarlyExitException eee =
                                    new EarlyExitException(4, input);
                                throw eee;
                        }
                        cnt4++;
                    } while (true);


                    match('.'); 

                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:30:25: ( '0' .. '9' )*
                    loop5:
                    do {
                        int alt5=2;
                        int LA5_0 = input.LA(1);

                        if ( ((LA5_0 >= '0' && LA5_0 <= '9')) ) {
                            alt5=1;
                        }


                        switch (alt5) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);


                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:30:37: ( EXPONENT )?
                    int alt6=2;
                    int LA6_0 = input.LA(1);

                    if ( (LA6_0=='E'||LA6_0=='e') ) {
                        alt6=1;
                    }
                    switch (alt6) {
                        case 1 :
                            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:30:37: EXPONENT
                            {
                            mEXPONENT(); 


                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:31:9: '.' ( '0' .. '9' )+ ( EXPONENT )?
                    {
                    match('.'); 

                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:31:13: ( '0' .. '9' )+
                    int cnt7=0;
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( ((LA7_0 >= '0' && LA7_0 <= '9')) ) {
                            alt7=1;
                        }


                        switch (alt7) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt7 >= 1 ) break loop7;
                                EarlyExitException eee =
                                    new EarlyExitException(7, input);
                                throw eee;
                        }
                        cnt7++;
                    } while (true);


                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:31:25: ( EXPONENT )?
                    int alt8=2;
                    int LA8_0 = input.LA(1);

                    if ( (LA8_0=='E'||LA8_0=='e') ) {
                        alt8=1;
                    }
                    switch (alt8) {
                        case 1 :
                            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:31:25: EXPONENT
                            {
                            mEXPONENT(); 


                            }
                            break;

                    }


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:32:9: ( '0' .. '9' )+ EXPONENT
                    {
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:32:9: ( '0' .. '9' )+
                    int cnt9=0;
                    loop9:
                    do {
                        int alt9=2;
                        int LA9_0 = input.LA(1);

                        if ( ((LA9_0 >= '0' && LA9_0 <= '9')) ) {
                            alt9=1;
                        }


                        switch (alt9) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
                    	    {
                    	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt9 >= 1 ) break loop9;
                                EarlyExitException eee =
                                    new EarlyExitException(9, input);
                                throw eee;
                        }
                        cnt9++;
                    } while (true);


                    mEXPONENT(); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "FLOAT"

    // $ANTLR start "COMMENT"
    public final void mCOMMENT() throws RecognitionException {
        try {
            int _type = COMMENT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:36:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0=='/') ) {
                int LA14_1 = input.LA(2);

                if ( (LA14_1=='/') ) {
                    alt14=1;
                }
                else if ( (LA14_1=='*') ) {
                    alt14=2;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 14, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;

            }
            switch (alt14) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:36:9: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
                    {
                    match("//"); 



                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:36:14: (~ ( '\\n' | '\\r' ) )*
                    loop11:
                    do {
                        int alt11=2;
                        int LA11_0 = input.LA(1);

                        if ( ((LA11_0 >= '\u0000' && LA11_0 <= '\t')||(LA11_0 >= '\u000B' && LA11_0 <= '\f')||(LA11_0 >= '\u000E' && LA11_0 <= '\uFFFF')) ) {
                            alt11=1;
                        }


                        switch (alt11) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
                    	    {
                    	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) {
                    	        input.consume();
                    	    }
                    	    else {
                    	        MismatchedSetException mse = new MismatchedSetException(null,input);
                    	        recover(mse);
                    	        throw mse;
                    	    }


                    	    }
                    	    break;

                    	default :
                    	    break loop11;
                        }
                    } while (true);


                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:36:28: ( '\\r' )?
                    int alt12=2;
                    int LA12_0 = input.LA(1);

                    if ( (LA12_0=='\r') ) {
                        alt12=1;
                    }
                    switch (alt12) {
                        case 1 :
                            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:36:28: '\\r'
                            {
                            match('\r'); 

                            }
                            break;

                    }


                    match('\n'); 

                    _channel=HIDDEN;

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:37:9: '/*' ( options {greedy=false; } : . )* '*/'
                    {
                    match("/*"); 



                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:37:14: ( options {greedy=false; } : . )*
                    loop13:
                    do {
                        int alt13=2;
                        int LA13_0 = input.LA(1);

                        if ( (LA13_0=='*') ) {
                            int LA13_1 = input.LA(2);

                            if ( (LA13_1=='/') ) {
                                alt13=2;
                            }
                            else if ( ((LA13_1 >= '\u0000' && LA13_1 <= '.')||(LA13_1 >= '0' && LA13_1 <= '\uFFFF')) ) {
                                alt13=1;
                            }


                        }
                        else if ( ((LA13_0 >= '\u0000' && LA13_0 <= ')')||(LA13_0 >= '+' && LA13_0 <= '\uFFFF')) ) {
                            alt13=1;
                        }


                        switch (alt13) {
                    	case 1 :
                    	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:37:42: .
                    	    {
                    	    matchAny(); 

                    	    }
                    	    break;

                    	default :
                    	    break loop13;
                        }
                    } while (true);


                    match("*/"); 



                    _channel=HIDDEN;

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMMENT"

    // $ANTLR start "SPACE"
    public final void mSPACE() throws RecognitionException {
        try {
            int _type = SPACE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:41:5: ( ( ' ' | '\\t' )+ )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:41:9: ( ' ' | '\\t' )+
            {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:41:9: ( ' ' | '\\t' )+
            int cnt15=0;
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( (LA15_0=='\t'||LA15_0==' ') ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            	    {
            	    if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt15 >= 1 ) break loop15;
                        EarlyExitException eee =
                            new EarlyExitException(15, input);
                        throw eee;
                }
                cnt15++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SPACE"

    // $ANTLR start "CJTOCAR"
    public final void mCJTOCAR() throws RecognitionException {
        try {
            int _type = CJTOCAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:50:5: ( '[' ( RANGO )+ ']' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:50:7: '[' ( RANGO )+ ']'
            {
            match('['); 

            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:50:11: ( RANGO )+
            int cnt16=0;
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( (LA16_0==' '||LA16_0=='%'||(LA16_0 >= '0' && LA16_0 <= '9')||LA16_0=='='||(LA16_0 >= 'A' && LA16_0 <= 'Z')||LA16_0=='\\'||(LA16_0 >= 'a' && LA16_0 <= 'z')) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:50:11: RANGO
            	    {
            	    mRANGO(); 


            	    }
            	    break;

            	default :
            	    if ( cnt16 >= 1 ) break loop16;
                        EarlyExitException eee =
                            new EarlyExitException(16, input);
                        throw eee;
                }
                cnt16++;
            } while (true);


            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CJTOCAR"

    // $ANTLR start "RANGO"
    public final void mRANGO() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:56:7: ( CAR '-' CAR )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:56:9: CAR '-' CAR
            {
            mCAR(); 


            match('-'); 

            mCAR(); 


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "RANGO"

    // $ANTLR start "IND"
    public final void mIND() throws RecognitionException {
        try {
            int _type = IND;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:58:7: ( '[' INT ']' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:58:9: '[' INT ']'
            {
            match('['); 

            mINT(); 


            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "IND"

    // $ANTLR start "STRING"
    public final void mSTRING() throws RecognitionException {
        try {
            int _type = STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:62:8: ( '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:62:11: '\"' ( ESC_SEQ |~ ( '\\\\' | '\"' ) )* '\"'
            {
            match('\"'); 

            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:62:15: ( ESC_SEQ |~ ( '\\\\' | '\"' ) )*
            loop17:
            do {
                int alt17=3;
                int LA17_0 = input.LA(1);

                if ( (LA17_0=='\\') ) {
                    alt17=1;
                }
                else if ( ((LA17_0 >= '\u0000' && LA17_0 <= '!')||(LA17_0 >= '#' && LA17_0 <= '[')||(LA17_0 >= ']' && LA17_0 <= '\uFFFF')) ) {
                    alt17=2;
                }


                switch (alt17) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:62:17: ESC_SEQ
            	    {
            	    mESC_SEQ(); 


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:62:27: ~ ( '\\\\' | '\"' )
            	    {
            	    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);


            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "STRING"

    // $ANTLR start "CHAR"
    public final void mCHAR() throws RecognitionException {
        try {
            int _type = CHAR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:65:5: ( '\\'' ( ESC_SEQ |~ ( '\\'' | '\\\\' ) ) '\\'' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:65:8: '\\'' ( ESC_SEQ |~ ( '\\'' | '\\\\' ) ) '\\''
            {
            match('\''); 

            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:65:13: ( ESC_SEQ |~ ( '\\'' | '\\\\' ) )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0=='\\') ) {
                alt18=1;
            }
            else if ( ((LA18_0 >= '\u0000' && LA18_0 <= '&')||(LA18_0 >= '(' && LA18_0 <= '[')||(LA18_0 >= ']' && LA18_0 <= '\uFFFF')) ) {
                alt18=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;

            }
            switch (alt18) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:65:15: ESC_SEQ
                    {
                    mESC_SEQ(); 


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:65:25: ~ ( '\\'' | '\\\\' )
                    {
                    if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '[')||(input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }


            match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CHAR"

    // $ANTLR start "EXPONENT"
    public final void mEXPONENT() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:70:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:70:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
            {
            if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:70:22: ( '+' | '-' )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0=='+'||LA19_0=='-') ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
                    {
                    if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:70:33: ( '0' .. '9' )+
            int cnt20=0;
            loop20:
            do {
                int alt20=2;
                int LA20_0 = input.LA(1);

                if ( ((LA20_0 >= '0' && LA20_0 <= '9')) ) {
                    alt20=1;
                }


                switch (alt20) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            	    {
            	    if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
            	        input.consume();
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;
            	    }


            	    }
            	    break;

            	default :
            	    if ( cnt20 >= 1 ) break loop20;
                        EarlyExitException eee =
                            new EarlyExitException(20, input);
                        throw eee;
                }
                cnt20++;
            } while (true);


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "EXPONENT"

    // $ANTLR start "HEX_DIGIT"
    public final void mHEX_DIGIT() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:73:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:
            {
            if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
                input.consume();
            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;
            }


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "HEX_DIGIT"

    // $ANTLR start "ESC_SEQ"
    public final void mESC_SEQ() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:77:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC | OCTAL_ESC )
            int alt21=3;
            int LA21_0 = input.LA(1);

            if ( (LA21_0=='\\') ) {
                switch ( input.LA(2) ) {
                case '\"':
                case '\'':
                case '\\':
                case 'b':
                case 'f':
                case 'n':
                case 'r':
                case 't':
                    {
                    alt21=1;
                    }
                    break;
                case 'u':
                    {
                    alt21=2;
                    }
                    break;
                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                    {
                    alt21=3;
                    }
                    break;
                default:
                    NoViableAltException nvae =
                        new NoViableAltException("", 21, 1, input);

                    throw nvae;

                }

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;

            }
            switch (alt21) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:77:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
                    {
                    match('\\'); 

                    if ( input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||input.LA(1)=='b'||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t' ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:78:9: UNICODE_ESC
                    {
                    mUNICODE_ESC(); 


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:79:9: OCTAL_ESC
                    {
                    mOCTAL_ESC(); 


                    }
                    break;

            }

        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ESC_SEQ"

    // $ANTLR start "OCTAL_ESC"
    public final void mOCTAL_ESC() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:84:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
            int alt22=3;
            int LA22_0 = input.LA(1);

            if ( (LA22_0=='\\') ) {
                int LA22_1 = input.LA(2);

                if ( ((LA22_1 >= '0' && LA22_1 <= '3')) ) {
                    int LA22_2 = input.LA(3);

                    if ( ((LA22_2 >= '0' && LA22_2 <= '7')) ) {
                        int LA22_4 = input.LA(4);

                        if ( ((LA22_4 >= '0' && LA22_4 <= '7')) ) {
                            alt22=1;
                        }
                        else {
                            alt22=2;
                        }
                    }
                    else {
                        alt22=3;
                    }
                }
                else if ( ((LA22_1 >= '4' && LA22_1 <= '7')) ) {
                    int LA22_3 = input.LA(3);

                    if ( ((LA22_3 >= '0' && LA22_3 <= '7')) ) {
                        alt22=2;
                    }
                    else {
                        alt22=3;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 22, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;

            }
            switch (alt22) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:84:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 

                    if ( (input.LA(1) >= '0' && input.LA(1) <= '3') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:85:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
                    {
                    match('\\'); 

                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;
                case 3 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:86:9: '\\\\' ( '0' .. '7' )
                    {
                    match('\\'); 

                    if ( (input.LA(1) >= '0' && input.LA(1) <= '7') ) {
                        input.consume();
                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;
                    }


                    }
                    break;

            }

        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OCTAL_ESC"

    // $ANTLR start "UNICODE_ESC"
    public final void mUNICODE_ESC() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:91:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:91:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
            {
            match('\\'); 

            match('u'); 

            mHEX_DIGIT(); 


            mHEX_DIGIT(); 


            mHEX_DIGIT(); 


            mHEX_DIGIT(); 


            }


        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "UNICODE_ESC"

    // $ANTLR start "NEWLINE"
    public final void mNEWLINE() throws RecognitionException {
        try {
            int _type = NEWLINE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:93:9: ( ( '\\r' )? '\\n' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:93:10: ( '\\r' )? '\\n'
            {
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:93:10: ( '\\r' )?
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0=='\r') ) {
                alt23=1;
            }
            switch (alt23) {
                case 1 :
                    // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:93:10: '\\r'
                    {
                    match('\r'); 

                    }
                    break;

            }


            match('\n'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "NEWLINE"

    // $ANTLR start "SECCION"
    public final void mSECCION() throws RecognitionException {
        try {
            int _type = SECCION;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:95:9: ( '%%' NEWLINE )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:95:11: '%%' NEWLINE
            {
            match("%%"); 



            mNEWLINE(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SECCION"

    // $ANTLR start "BLOQOP"
    public final void mBLOQOP() throws RecognitionException {
        try {
            int _type = BLOQOP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:97:7: ( '%{' NEWLINE )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:97:9: '%{' NEWLINE
            {
            match("%{"); 



            mNEWLINE(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BLOQOP"

    // $ANTLR start "BLOQCL"
    public final void mBLOQCL() throws RecognitionException {
        try {
            int _type = BLOQCL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:99:7: ( '%}' NEWLINE )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:99:9: '%}' NEWLINE
            {
            match("%}"); 



            mNEWLINE(); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "BLOQCL"

    // $ANTLR start "SEMI"
    public final void mSEMI() throws RecognitionException {
        try {
            int _type = SEMI;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:101:7: ( ';' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:101:9: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "SEMI"

    // $ANTLR start "REF"
    public final void mREF() throws RecognitionException {
        try {
            int _type = REF;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:103:7: ( '{' ID '}' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:103:9: '{' ID '}'
            {
            match('{'); 

            mID(); 


            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "REF"

    // $ANTLR start "LLAVOP"
    public final void mLLAVOP() throws RecognitionException {
        try {
            int _type = LLAVOP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:105:9: ( '{' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:105:11: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LLAVOP"

    // $ANTLR start "LLAVCL"
    public final void mLLAVCL() throws RecognitionException {
        try {
            int _type = LLAVCL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:106:9: ( '}' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:106:11: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "LLAVCL"

    // $ANTLR start "COMA"
    public final void mCOMA() throws RecognitionException {
        try {
            int _type = COMA;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:108:9: ( ',' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:108:11: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COMA"

    // $ANTLR start "EQ"
    public final void mEQ() throws RecognitionException {
        try {
            int _type = EQ;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:110:9: ( '=' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:110:11: '='
            {
            match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "EQ"

    // $ANTLR start "PAROP"
    public final void mPAROP() throws RecognitionException {
        try {
            int _type = PAROP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:112:9: ( '(' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:112:11: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PAROP"

    // $ANTLR start "PARCL"
    public final void mPARCL() throws RecognitionException {
        try {
            int _type = PARCL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:113:9: ( ')' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:113:11: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PARCL"

    // $ANTLR start "COROP"
    public final void mCOROP() throws RecognitionException {
        try {
            int _type = COROP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:114:9: ( '[' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:114:11: '['
            {
            match('['); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "COROP"

    // $ANTLR start "CORCL"
    public final void mCORCL() throws RecognitionException {
        try {
            int _type = CORCL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:115:9: ( ']' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:115:11: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "CORCL"

    // $ANTLR start "OR"
    public final void mOR() throws RecognitionException {
        try {
            int _type = OR;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:116:9: ( '|' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:116:11: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "ASTER"
    public final void mASTER() throws RecognitionException {
        try {
            int _type = ASTER;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:118:10: ( '*' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:118:13: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "ASTER"

    // $ANTLR start "PLUS"
    public final void mPLUS() throws RecognitionException {
        try {
            int _type = PLUS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:120:3: ( '+' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:120:5: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "OPINC"
    public final void mOPINC() throws RecognitionException {
        try {
            int _type = OPINC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:122:10: ( '++' )
            // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:122:17: '++'
            {
            match("++"); 



            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        	// do for sure before leaving
        }
    }
    // $ANTLR end "OPINC"

    public void mTokens() throws RecognitionException {
        // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:8: ( STR | ID | INT | FLOAT | COMMENT | SPACE | CJTOCAR | IND | STRING | CHAR | NEWLINE | SECCION | BLOQOP | BLOQCL | SEMI | REF | LLAVOP | LLAVCL | COMA | EQ | PAROP | PARCL | COROP | CORCL | OR | ASTER | PLUS | OPINC )
        int alt24=28;
        alt24 = dfa24.predict(input);
        switch (alt24) {
            case 1 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:10: STR
                {
                mSTR(); 


                }
                break;
            case 2 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:14: ID
                {
                mID(); 


                }
                break;
            case 3 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:17: INT
                {
                mINT(); 


                }
                break;
            case 4 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:21: FLOAT
                {
                mFLOAT(); 


                }
                break;
            case 5 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:27: COMMENT
                {
                mCOMMENT(); 


                }
                break;
            case 6 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:35: SPACE
                {
                mSPACE(); 


                }
                break;
            case 7 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:41: CJTOCAR
                {
                mCJTOCAR(); 


                }
                break;
            case 8 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:49: IND
                {
                mIND(); 


                }
                break;
            case 9 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:53: STRING
                {
                mSTRING(); 


                }
                break;
            case 10 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:60: CHAR
                {
                mCHAR(); 


                }
                break;
            case 11 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:65: NEWLINE
                {
                mNEWLINE(); 


                }
                break;
            case 12 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:73: SECCION
                {
                mSECCION(); 


                }
                break;
            case 13 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:81: BLOQOP
                {
                mBLOQOP(); 


                }
                break;
            case 14 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:88: BLOQCL
                {
                mBLOQCL(); 


                }
                break;
            case 15 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:95: SEMI
                {
                mSEMI(); 


                }
                break;
            case 16 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:100: REF
                {
                mREF(); 


                }
                break;
            case 17 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:104: LLAVOP
                {
                mLLAVOP(); 


                }
                break;
            case 18 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:111: LLAVCL
                {
                mLLAVCL(); 


                }
                break;
            case 19 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:118: COMA
                {
                mCOMA(); 


                }
                break;
            case 20 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:123: EQ
                {
                mEQ(); 


                }
                break;
            case 21 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:126: PAROP
                {
                mPAROP(); 


                }
                break;
            case 22 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:132: PARCL
                {
                mPARCL(); 


                }
                break;
            case 23 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:138: COROP
                {
                mCOROP(); 


                }
                break;
            case 24 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:144: CORCL
                {
                mCORCL(); 


                }
                break;
            case 25 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:150: OR
                {
                mOR(); 


                }
                break;
            case 26 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:153: ASTER
                {
                mASTER(); 


                }
                break;
            case 27 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:159: PLUS
                {
                mPLUS(); 


                }
                break;
            case 28 :
                // C:\\Users\\Jose\\workspaceN\\pract5\\src\\main\\java\\flexgram\\Flex.g:1:164: OPINC
                {
                mOPINC(); 


                }
                break;

        }

    }


    protected DFA10 dfa10 = new DFA10(this);
    protected DFA24 dfa24 = new DFA24(this);
    static final String DFA10_eotS =
        "\5\uffff";
    static final String DFA10_eofS =
        "\5\uffff";
    static final String DFA10_minS =
        "\2\56\3\uffff";
    static final String DFA10_maxS =
        "\1\71\1\145\3\uffff";
    static final String DFA10_acceptS =
        "\2\uffff\1\2\1\1\1\3";
    static final String DFA10_specialS =
        "\5\uffff}>";
    static final String[] DFA10_transitionS = {
            "\1\2\1\uffff\12\1",
            "\1\3\1\uffff\12\1\13\uffff\1\4\37\uffff\1\4",
            "",
            "",
            ""
    };

    static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
    static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
    static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
    static final short[][] DFA10_transition;

    static {
        int numStates = DFA10_transitionS.length;
        DFA10_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
        }
    }

    class DFA10 extends DFA {

        public DFA10(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;
        }
        public String getDescription() {
            return "29:1: FLOAT : ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( EXPONENT )? | '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '0' .. '9' )+ EXPONENT );";
        }
    }
    static final String DFA24_eotS =
        "\3\uffff\1\32\3\uffff\1\35\4\uffff\1\42\10\uffff\1\44\17\uffff\1"+
        "\52\15\uffff";
    static final String DFA24_eofS =
        "\63\uffff";
    static final String DFA24_minS =
        "\1\11\1\0\1\uffff\1\56\3\uffff\1\40\2\uffff\1\45\1\uffff\1\101\10"+
        "\uffff\1\53\1\40\1\uffff\1\0\2\uffff\1\55\11\uffff\1\0\1\40\3\0"+
        "\2\uffff\1\40\2\0\1\40\1\0\1\40\1\0";
    static final String DFA24_maxS =
        "\1\175\1\uffff\1\uffff\1\145\3\uffff\1\172\2\uffff\1\175\1\uffff"+
        "\1\172\10\uffff\1\53\1\172\1\uffff\1\uffff\2\uffff\1\135\11\uffff"+
        "\1\uffff\1\172\3\uffff\2\uffff\1\172\2\uffff\1\172\1\uffff\1\172"+
        "\1\uffff";
    static final String DFA24_acceptS =
        "\2\uffff\1\2\1\uffff\1\4\1\5\1\6\1\uffff\1\12\1\13\1\uffff\1\17"+
        "\1\uffff\1\22\1\23\1\24\1\25\1\26\1\30\1\31\1\32\2\uffff\1\1\1\uffff"+
        "\1\11\1\3\1\uffff\1\7\1\27\1\14\1\15\1\16\1\20\1\21\1\34\1\33\5"+
        "\uffff\1\1\1\10\7\uffff";
    static final String DFA24_specialS =
        "\1\uffff\1\4\26\uffff\1\3\14\uffff\1\6\1\uffff\1\10\1\0\1\5\3\uffff"+
        "\1\1\1\7\1\uffff\1\11\1\uffff\1\2}>";
    static final String[] DFA24_transitionS = {
            "\1\6\1\11\2\uffff\1\11\22\uffff\1\6\1\uffff\1\1\2\uffff\1\12"+
            "\1\uffff\1\10\1\20\1\21\1\24\1\25\1\16\1\uffff\1\4\1\5\12\3"+
            "\1\uffff\1\13\1\uffff\1\17\3\uffff\32\2\1\7\1\uffff\1\22\1\uffff"+
            "\1\2\1\uffff\32\2\1\14\1\23\1\15",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\12\30\3\31\1\30\3\31"+
            "\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "",
            "\1\4\1\uffff\12\3\13\uffff\1\4\37\uffff\1\4",
            "",
            "",
            "",
            "\1\34\4\uffff\1\34\12\uffff\12\33\3\uffff\1\34\3\uffff\32\34"+
            "\1\uffff\1\34\4\uffff\32\34",
            "",
            "",
            "\1\36\125\uffff\1\37\1\uffff\1\40",
            "",
            "\32\41\4\uffff\1\41\1\uffff\32\41",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\43",
            "\1\52\1\uffff\1\45\2\uffff\1\52\1\uffff\1\31\10\uffff\4\47"+
            "\4\50\2\52\3\uffff\1\52\3\uffff\32\52\1\uffff\1\51\4\uffff\1"+
            "\52\1\51\3\52\1\51\7\52\1\51\3\52\1\51\1\52\1\51\1\46\5\52",
            "",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\12\30\3\31\1\30\3\31"+
            "\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "",
            "",
            "\1\34\2\uffff\12\53\43\uffff\1\53",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\0\31",
            "\1\52\1\uffff\1\52\2\uffff\1\52\12\uffff\12\54\3\uffff\1\52"+
            "\3\uffff\6\54\24\52\1\uffff\1\52\4\uffff\6\54\24\52",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\10\55\2\30\3\31\1\30"+
            "\3\31\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\10\56\2\30\3\31\1\30"+
            "\3\31\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\12\30\3\31\1\30\3\31"+
            "\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "",
            "",
            "\1\52\1\uffff\1\52\2\uffff\1\52\12\uffff\12\57\3\uffff\1\52"+
            "\3\uffff\6\57\24\52\1\uffff\1\52\4\uffff\6\57\24\52",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\10\60\2\30\3\31\1\30"+
            "\3\31\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\12\30\3\31\1\30\3\31"+
            "\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "\1\52\1\uffff\1\52\2\uffff\1\52\12\uffff\12\61\3\uffff\1\52"+
            "\3\uffff\6\61\24\52\1\uffff\1\52\4\uffff\6\61\24\52",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\12\30\3\31\1\30\3\31"+
            "\32\30\1\31\1\26\4\31\32\30\uff85\31",
            "\1\52\1\uffff\1\52\2\uffff\1\52\12\uffff\12\62\3\uffff\1\52"+
            "\3\uffff\6\62\24\52\1\uffff\1\52\4\uffff\6\62\24\52",
            "\40\31\1\30\1\31\1\27\2\31\1\30\12\31\12\30\3\31\1\30\3\31"+
            "\32\30\1\31\1\26\4\31\32\30\uff85\31"
    };

    static final short[] DFA24_eot = DFA.unpackEncodedString(DFA24_eotS);
    static final short[] DFA24_eof = DFA.unpackEncodedString(DFA24_eofS);
    static final char[] DFA24_min = DFA.unpackEncodedStringToUnsignedChars(DFA24_minS);
    static final char[] DFA24_max = DFA.unpackEncodedStringToUnsignedChars(DFA24_maxS);
    static final short[] DFA24_accept = DFA.unpackEncodedString(DFA24_acceptS);
    static final short[] DFA24_special = DFA.unpackEncodedString(DFA24_specialS);
    static final short[][] DFA24_transition;

    static {
        int numStates = DFA24_transitionS.length;
        DFA24_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA24_transition[i] = DFA.unpackEncodedString(DFA24_transitionS[i]);
        }
    }

    class DFA24 extends DFA {

        public DFA24(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 24;
            this.eot = DFA24_eot;
            this.eof = DFA24_eof;
            this.min = DFA24_min;
            this.max = DFA24_max;
            this.accept = DFA24_accept;
            this.special = DFA24_special;
            this.transition = DFA24_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( STR | ID | INT | FLOAT | COMMENT | SPACE | CJTOCAR | IND | STRING | CHAR | NEWLINE | SECCION | BLOQOP | BLOQCL | SEMI | REF | LLAVOP | LLAVCL | COMA | EQ | PAROP | PARCL | COROP | CORCL | OR | ASTER | PLUS | OPINC );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA24_40 = input.LA(1);

                        s = -1;
                        if ( ((LA24_40 >= '0' && LA24_40 <= '7')) ) {s = 46;}

                        else if ( (LA24_40=='\"') ) {s = 23;}

                        else if ( (LA24_40=='\\') ) {s = 22;}

                        else if ( (LA24_40==' '||LA24_40=='%'||(LA24_40 >= '8' && LA24_40 <= '9')||LA24_40=='='||(LA24_40 >= 'A' && LA24_40 <= 'Z')||(LA24_40 >= 'a' && LA24_40 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_40 >= '\u0000' && LA24_40 <= '\u001F')||LA24_40=='!'||(LA24_40 >= '#' && LA24_40 <= '$')||(LA24_40 >= '&' && LA24_40 <= '/')||(LA24_40 >= ':' && LA24_40 <= '<')||(LA24_40 >= '>' && LA24_40 <= '@')||LA24_40=='['||(LA24_40 >= ']' && LA24_40 <= '`')||(LA24_40 >= '{' && LA24_40 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA24_45 = input.LA(1);

                        s = -1;
                        if ( ((LA24_45 >= '0' && LA24_45 <= '7')) ) {s = 48;}

                        else if ( (LA24_45=='\"') ) {s = 23;}

                        else if ( (LA24_45=='\\') ) {s = 22;}

                        else if ( (LA24_45==' '||LA24_45=='%'||(LA24_45 >= '8' && LA24_45 <= '9')||LA24_45=='='||(LA24_45 >= 'A' && LA24_45 <= 'Z')||(LA24_45 >= 'a' && LA24_45 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_45 >= '\u0000' && LA24_45 <= '\u001F')||LA24_45=='!'||(LA24_45 >= '#' && LA24_45 <= '$')||(LA24_45 >= '&' && LA24_45 <= '/')||(LA24_45 >= ':' && LA24_45 <= '<')||(LA24_45 >= '>' && LA24_45 <= '@')||LA24_45=='['||(LA24_45 >= ']' && LA24_45 <= '`')||(LA24_45 >= '{' && LA24_45 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA24_50 = input.LA(1);

                        s = -1;
                        if ( (LA24_50=='\"') ) {s = 23;}

                        else if ( (LA24_50=='\\') ) {s = 22;}

                        else if ( (LA24_50==' '||LA24_50=='%'||(LA24_50 >= '0' && LA24_50 <= '9')||LA24_50=='='||(LA24_50 >= 'A' && LA24_50 <= 'Z')||(LA24_50 >= 'a' && LA24_50 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_50 >= '\u0000' && LA24_50 <= '\u001F')||LA24_50=='!'||(LA24_50 >= '#' && LA24_50 <= '$')||(LA24_50 >= '&' && LA24_50 <= '/')||(LA24_50 >= ':' && LA24_50 <= '<')||(LA24_50 >= '>' && LA24_50 <= '@')||LA24_50=='['||(LA24_50 >= ']' && LA24_50 <= '`')||(LA24_50 >= '{' && LA24_50 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA24_24 = input.LA(1);

                        s = -1;
                        if ( (LA24_24=='\"') ) {s = 23;}

                        else if ( (LA24_24=='\\') ) {s = 22;}

                        else if ( (LA24_24==' '||LA24_24=='%'||(LA24_24 >= '0' && LA24_24 <= '9')||LA24_24=='='||(LA24_24 >= 'A' && LA24_24 <= 'Z')||(LA24_24 >= 'a' && LA24_24 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_24 >= '\u0000' && LA24_24 <= '\u001F')||LA24_24=='!'||(LA24_24 >= '#' && LA24_24 <= '$')||(LA24_24 >= '&' && LA24_24 <= '/')||(LA24_24 >= ':' && LA24_24 <= '<')||(LA24_24 >= '>' && LA24_24 <= '@')||LA24_24=='['||(LA24_24 >= ']' && LA24_24 <= '`')||(LA24_24 >= '{' && LA24_24 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA24_1 = input.LA(1);

                        s = -1;
                        if ( (LA24_1=='\\') ) {s = 22;}

                        else if ( (LA24_1=='\"') ) {s = 23;}

                        else if ( (LA24_1==' '||LA24_1=='%'||(LA24_1 >= '0' && LA24_1 <= '9')||LA24_1=='='||(LA24_1 >= 'A' && LA24_1 <= 'Z')||(LA24_1 >= 'a' && LA24_1 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_1 >= '\u0000' && LA24_1 <= '\u001F')||LA24_1=='!'||(LA24_1 >= '#' && LA24_1 <= '$')||(LA24_1 >= '&' && LA24_1 <= '/')||(LA24_1 >= ':' && LA24_1 <= '<')||(LA24_1 >= '>' && LA24_1 <= '@')||LA24_1=='['||(LA24_1 >= ']' && LA24_1 <= '`')||(LA24_1 >= '{' && LA24_1 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA24_41 = input.LA(1);

                        s = -1;
                        if ( (LA24_41=='\"') ) {s = 23;}

                        else if ( (LA24_41=='\\') ) {s = 22;}

                        else if ( (LA24_41==' '||LA24_41=='%'||(LA24_41 >= '0' && LA24_41 <= '9')||LA24_41=='='||(LA24_41 >= 'A' && LA24_41 <= 'Z')||(LA24_41 >= 'a' && LA24_41 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_41 >= '\u0000' && LA24_41 <= '\u001F')||LA24_41=='!'||(LA24_41 >= '#' && LA24_41 <= '$')||(LA24_41 >= '&' && LA24_41 <= '/')||(LA24_41 >= ':' && LA24_41 <= '<')||(LA24_41 >= '>' && LA24_41 <= '@')||LA24_41=='['||(LA24_41 >= ']' && LA24_41 <= '`')||(LA24_41 >= '{' && LA24_41 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA24_37 = input.LA(1);

                        s = -1;
                        if ( ((LA24_37 >= '\u0000' && LA24_37 <= '\uFFFF')) ) {s = 25;}

                        else s = 42;

                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA24_46 = input.LA(1);

                        s = -1;
                        if ( (LA24_46=='\"') ) {s = 23;}

                        else if ( (LA24_46=='\\') ) {s = 22;}

                        else if ( (LA24_46==' '||LA24_46=='%'||(LA24_46 >= '0' && LA24_46 <= '9')||LA24_46=='='||(LA24_46 >= 'A' && LA24_46 <= 'Z')||(LA24_46 >= 'a' && LA24_46 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_46 >= '\u0000' && LA24_46 <= '\u001F')||LA24_46=='!'||(LA24_46 >= '#' && LA24_46 <= '$')||(LA24_46 >= '&' && LA24_46 <= '/')||(LA24_46 >= ':' && LA24_46 <= '<')||(LA24_46 >= '>' && LA24_46 <= '@')||LA24_46=='['||(LA24_46 >= ']' && LA24_46 <= '`')||(LA24_46 >= '{' && LA24_46 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA24_39 = input.LA(1);

                        s = -1;
                        if ( ((LA24_39 >= '0' && LA24_39 <= '7')) ) {s = 45;}

                        else if ( (LA24_39=='\"') ) {s = 23;}

                        else if ( (LA24_39=='\\') ) {s = 22;}

                        else if ( (LA24_39==' '||LA24_39=='%'||(LA24_39 >= '8' && LA24_39 <= '9')||LA24_39=='='||(LA24_39 >= 'A' && LA24_39 <= 'Z')||(LA24_39 >= 'a' && LA24_39 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_39 >= '\u0000' && LA24_39 <= '\u001F')||LA24_39=='!'||(LA24_39 >= '#' && LA24_39 <= '$')||(LA24_39 >= '&' && LA24_39 <= '/')||(LA24_39 >= ':' && LA24_39 <= '<')||(LA24_39 >= '>' && LA24_39 <= '@')||LA24_39=='['||(LA24_39 >= ']' && LA24_39 <= '`')||(LA24_39 >= '{' && LA24_39 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA24_48 = input.LA(1);

                        s = -1;
                        if ( (LA24_48=='\"') ) {s = 23;}

                        else if ( (LA24_48=='\\') ) {s = 22;}

                        else if ( (LA24_48==' '||LA24_48=='%'||(LA24_48 >= '0' && LA24_48 <= '9')||LA24_48=='='||(LA24_48 >= 'A' && LA24_48 <= 'Z')||(LA24_48 >= 'a' && LA24_48 <= 'z')) ) {s = 24;}

                        else if ( ((LA24_48 >= '\u0000' && LA24_48 <= '\u001F')||LA24_48=='!'||(LA24_48 >= '#' && LA24_48 <= '$')||(LA24_48 >= '&' && LA24_48 <= '/')||(LA24_48 >= ':' && LA24_48 <= '<')||(LA24_48 >= '>' && LA24_48 <= '@')||LA24_48=='['||(LA24_48 >= ']' && LA24_48 <= '`')||(LA24_48 >= '{' && LA24_48 <= '\uFFFF')) ) {s = 25;}

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 24, _s, input);
            error(nvae);
            throw nvae;
        }

    }
 

}